home *** CD-ROM | disk | FTP | other *** search
/ Light ROM 1 / LIGHT-ROM 1 (Amiga Library Services)(1994).iso / ffdisks / d931.lha / Modules / IntuitionSupport / IntuitionSupport.def / IntuitionSupport.def
Text File  |  1993-12-20  |  56KB  |  1,285 lines
  1. DEFINITION MODULE IntuitionSupport;
  2.  
  3. (* Version 1.1                                                          *)
  4. (* Diese Routinen unterstützen die Programmierung der Intuitionlibrary. *)
  5. (* Es werden die Behandlung von Screens, Windows, Images, Borders,      *)
  6. (* IntuiTexts, Menus, Gadgets und Requester unterstützt.                *)
  7. (* Die Files IntuitionSupport.obj und IntuitionSupport.sym sind         *)
  8. (* Copyright-frei. Sie dürfen auch in kommerziellen Produkten benutzt   *)
  9. (* werden. Diese Files dürfen allerdings nur mit den Sourcecodes und    *)
  10. (* dem Demo weitergegeben werden.                                       *)
  11. (* Jeder Art Änderungen am Sourcecode oder am Definitionsfile ohne      *)
  12. (* meine ausdrückliche Genehmigung sind verboten. Das Definitionsfile   *)
  13. (* und der Sourcecode, sowie Teile daraus, sind Copyrightgeschützt!     *)
  14. (*                      © 1991 by Andre Wiethoff                        *)
  15. (*                                                                      *)
  16. (* Bei Verbesserungsvorschlägen, Fehlern oder bei Fragen:               *)
  17. (* Andre Wiethoff                                                       *)
  18. (* Höhenweg 2                                                           *)
  19. (* D-57392 Schmallenberg / Germany                                      *)
  20.  
  21.  
  22. FROM SYSTEM       IMPORT LONGSET,ADDRESS;
  23. FROM IntuitionD   IMPORT WindowPtr,MenuPtr,MenuItemPtr,RequesterPtr,Gadget,
  24.                          GadgetPtr,BoolInfo,PropInfo,StringInfo,ScreenFlagSet,
  25.                          ScreenPtr,IDCMPFlags,WindowFlagSet,ImagePtr,
  26.                          IntuiTextPtr,IntuiMessage,IDCMPFlagSet;
  27. FROM GraphicsD    IMPORT DrawModeSet,TextAttr,TextAttrPtr,TextFontPtr,
  28.                          ViewModeSet,RastPortPtr,FontStyleSet,BitMapPtr;
  29. FROM FileSystem   IMPORT File;
  30. FROM KeyMapD      IMPORT KeyMapPtr;
  31. FROM RememberHeap IMPORT NewRememberPtr;
  32.  
  33. (* 'borderX' und 'borderY' können in der Borderstruktur benutzt werden  *)
  34. (* um die Eckpositionen direkt im Array ablegen zu können. z.B. kann    *)
  35. (* ein Punkt so in der Struktur abgelegt werden : b^.xy[0,borderX]:=x;  *)
  36. (* b^.xy[0,borderY]:=y; (Es wird der erste Punkt definiert)             *)
  37.  
  38. CONST borderX = 0;
  39.       borderY = 1;
  40.  
  41.  
  42. (* 'none' kann bei den Menufunktionen benutzt werden, um anzugegeben,   *)
  43. (* daß kein String übergeben wird.                                      *)
  44.  
  45.       none         = CHR(0);
  46.  
  47. (* 'noModify' kann bei dem Befehl 'ModifyTextItem' benutzt werden um    *)
  48. (* anzuzeigen, daß keine Änderung des Selektionstextes gewünscht wird.  *)
  49.  
  50.       noModify     = CHR(1);
  51.  
  52.  
  53. (* 'noImage' kann anstatt eines Zeigers auf ein Image übergeben werden, *)
  54. (* wenn kein Selectionsimage gewünscht ist.                             *)
  55.  
  56.       noImage      = NIL;
  57.  
  58.  
  59. (* 'standart' und 'center' können bei 'SetXOffset' dazu benutzt werden  *)
  60. (* den Abstand vom linken Rand anzugeben. Bei 'standart' befindet sich  *)
  61. (* der Text so weit wie möglich links, bei 'center' in der Mitte.       *)
  62.  
  63.       standart     = 0;
  64.       center       = -1;
  65.  
  66.  
  67. (* 'enabled' und 'disabled' können bei allen ...Enable-Befehlen (z.B.   *)
  68. (* MenuEnable, GadgetEnable ...) benutzt werden um anzuzeigen, ob das   *)
  69. (* jeweilige Objekt anwählbar ('enabled') oder nicht anwählbar          *)
  70. (* ('disabled') gesetzt werden soll.                                    *)
  71.  
  72.       enabled      = TRUE;
  73.       disabled     = FALSE;
  74.  
  75.  
  76. (* 'stdFont' und 'stdHeight' können bei 'InitMenu' und 'InitGadgetList' *)
  77. (* benutzt werden, um den Standart Topaz 8 Font bei den Menus bzw.      *)
  78. (* Gadgets zu benutzen.                                                 *)
  79.  
  80.       stdFont      = "topaz";
  81.       stdHeight    = 8;
  82.  
  83.  
  84. (* 'Made' und 'MadeSet' sind nur zur internen Benutzung freigegeben!    *)
  85.  
  86. TYPE Made = (menu,item,subItem);
  87.      MadeSet = SET OF Made;
  88.  
  89.  
  90. (* Das 'ItemFlagSet' enthält einige Flags die bei der Menuerstellung    *)
  91. (* benutzt werden müssen. Hier die Bedeutungen :                        *)
  92. (* 'checkit'   : Das jeweilige Menu(Sub)Item wird als Schalter benutzt. *)
  93. (*               Es wird auf der linken Seite etwas Platz für den       *)
  94. (*               Selektionshaken freigelassen. Bei der Anwahl eines     *)
  95. (*               solchen Items wird immer zwischen nicht gesetzt und    *)
  96. (*               gesetzt hergeschaltet. Mittels der Funktion            *)
  97. (*               'MenuItemChecked' kann abgefragt werden ob es gesetzt  *)
  98. (*               ist oder nicht. Beim Start ist es nicht gesetzt.       *)
  99. (* 'checkset'  : Es gilt das gleiche wie bei 'checkit' nur ist das Item *)
  100. (*               beim Start schon gesetzt.                              *)
  101. (* 'box'       : Wenn der Mauspfeil über dem Item steht wird ein Rahmen *)
  102. (*               um das Item bezogen.                                   *)
  103. (* 'invert'    : Wie bei 'box' nur wird das Feld invertiert.            *)
  104. (* 'non'       : Wie bei 'box' nur passiert garnichts.                  *)
  105. (* 'disable'   : Das jeweilige Item ist beim Start nicht anwählbar und  *)
  106. (*               kann im Laufe des Programms mittels 'MenuItemEnable'   *)
  107. (*               wieder zugelassen werden.                              *)
  108.  
  109.      ItemFlags     = (checkit,checkset,box,invert,non,disable);
  110.      ItemFlagSet   = SET OF ItemFlags;
  111.  
  112.  
  113. (* 'MessageType' enthält die Art der empfangenen Message die bei der    *)
  114. (* Funktion 'WaitForPossibleAction' zurückgegeben wird. Wenn es sich um *)
  115. (* eine Menuanwahl handelte, wird 'menuSelected' zurückgegeben, um sie  *)
  116. (* dann mittels 'GetMenuSelection' auszulesen. Wenn es sich um eine     *)
  117. (* Gadgetanwahl handelte wird eines der Gadgetflags zurückgegeben, um   *)
  118. (* das Ereignis mittels 'GetGadgetSelection' auszulesen. Bei            *)
  119. (* 'requesterSet' wurde ein Requester aktiviert und bei                 *)
  120. (* 'requesterCleared' einer deaktiviert. Dieses ist bei DoubleMenu-     *)
  121. (* Requestern nützlich. Wenn es sich allerdings um 'otherStuff'         *)
  122. (* handelt, muß die Nachricht mittels 'GetIntuiMessage' ausgelesen und  *)
  123. (* von Hand ausgewertet werden.                                         *)
  124.  
  125.      MessageType = (menuSelected,gadgetSelected,gadgetReleased,
  126.                     requesterSet,requesterCleared,otherStuff);
  127.  
  128.  
  129. (* 'GadgetType' ist nur für die interne Benutzung freigegeben!          *)
  130.  
  131.      GadgetType      = (boolean,proport,string);
  132.  
  133.  
  134. (* 'BoolGadgetFlagSet' enthält einige Flags die bei der Erstellung von  *)
  135. (* Boolean-Gadgets erforderlich sind. Hier ihre Bedeutungen :           *)
  136. (* 'bgBox'      : Bei Anwahl des jeweiligen Gadgets wird ein Rahmen um  *)
  137. (*                es gezogen.                                           *)
  138. (* 'bgInversid' : Bei Anwahl des jeweiligen Gadgets wird es invertiert. *)
  139. (* 'bgToggle'   : Es handelt sich dei dem Gadget um einen Ein-Aus       *)
  140. (*                Schalter, der beim Start ausgeschaltet ist.           *)
  141. (* 'bgSelected' : Es gilt das gleiche wie bei 'bgToggle', allerdings    *)
  142. (*                ist es beim Start schon eingeschaltet.                *)
  143. (* 'bgDisabled' : Das Gadget ist beim Start nicht anwählbar. Erst nach  *)
  144. (*                Benutzung des Befehls 'GadgetEnable' kann das Gadget  *)
  145. (*                angewählt werden.                                     *)
  146.  
  147.      BoolGadgetFlags   = (bgBox,bgInversid,bgToggle,bgSelected,bgDisabled);
  148.      BoolGadgetFlagSet = SET OF BoolGadgetFlags;
  149.  
  150.  
  151. (* 'PropGadgetFlags' enthält einige Flags die bei der Erstellung von    *)
  152. (* Proporional-Gadgets benötigt werden. Die Bedeutungen :               *)
  153. (* 'pgDisabled'   : siehe 'BoolGadgetFlagSet' - 'bgDisabled'.           *)
  154. (* 'pgBorderless' : Um das Proportionalgadget wird kein Rahmen          *)
  155. (*                  gezeichnet.                                         *)
  156. (* 'pgFollow'     : Im Window wird ein Flag gesetzt, daß bei            *)
  157. (*                  Mausbewegungen eine Nachricht sendet wird. So kann  *)
  158. (*                  bei Proportionalgadgets eine Bewegung des Reglers   *)
  159. (*                  sofort ausgewertet werden.                          *)
  160. (* 'pgInversid'   : Invertiert den Reglerknopf bei der Anwahl. Wenn     *)
  161. (*                  dieses Flag nicht gesetzt wird, passiert nichts.    *)
  162.  
  163.      PropGadgetFlags   = (pgDisabled,pgBorderless,pgFollow,pgInversid);
  164.      PropGadgetFlagSet = SET OF PropGadgetFlags;
  165.  
  166.  
  167. (* 'StringGadgetFlagSet' enthält einige Flags die bei der Erstellung    *)
  168. (* von String-Gadgets benötigt werden. Die Bedeutungen :                *)
  169. (* 'sgLongint'  : Das Gadget erwartet die Eingabe einer LONGINT-Zahl.   *)
  170. (*                Bei der Abfrage des Gadgets wird die eingegebene      *)
  171. (*                Zahl sofort mit übergeben.                            *)
  172. (* 'sgCentered' : Das Stringgadget gibt den Text mittelzentriert aus.   *)
  173. (* 'sgRight'    : Das Gadget gibt den Text rechtszentriert aus.         *)
  174. (* 'sgDisabled' : siehe 'BoolGadgetFlagSet' - 'bgDisabled'.             *)
  175. (* 'sgBox'      : Normalerweise wird als Cursor das Zeichen unter dem   *)
  176. (*                Cursor invertiert dargestellt, wenn aber 'sgBox'      *)
  177. (*                gesetzt ist, wird das jeweilige Zeichen umrahmt.      *)
  178.  
  179.      StringGadgetFlags   = (sgLongint,sgCentered,sgRight,sgDisabled,sgBox);
  180.      StringGadgetFlagSet = SET OF StringGadgetFlags;
  181.  
  182.  
  183. (* 'RequestFlagSet' enthält einige Flags die bei der Erstellung von     *)
  184. (* von Customrequestern benötigt werden. Die Bedeutungen :              *)
  185. (* 'noisy'          : Alle nicht den Requester betreffenden Nachrichten *)
  186. (*                    werden abgeblockt.                                *)
  187. (* 'relDMRequester' : Der Requester soll ein zur Mausposition relativer *)
  188. (*                    DoubleMenu-Requester werden. (DoubleMenu bedeutet,*)
  189. (*                    daß der Requester bei zweimaligen Druck auf die   *)
  190. (*                    Menuauswahltaste erscheint.)                      *)
  191. (* 'absDMRequester' : Der Requester soll ein DMRequester werden, der    *)
  192. (*                    absolute Koordinaten besitzt.                     *)
  193.  
  194.      RequestFlags = (noisy,relDMRequester,absDMRequester);
  195.      RequestFlagSet = SET OF RequestFlags;
  196.  
  197.  
  198. (* 'Border' ist eine verbesserte Borderstruktur, um sofort auf ihre     *)
  199. (* Koordinaten zugreifen zu können. Allerdings bleibt es dem Benutzer   *)
  200. (* überlassen, zu prüfen, ob die Werte sich im zulässigen Bereich       *)
  201. (* befinden! Den Pointer 'BorderPtr' erhält man z.B. bei 'GetBorder'    *)
  202. (* zurück. Dort wird auch angegeben, für wieviele Koordinatenpaare      *)
  203. (* Speicher belegt werden soll. Daher dürfen nur die Elemente des 'xy'  *)
  204. (* Arrays bis zu diesen Wert benutzt werden! (Und nicht bis 255!)       *)
  205.  
  206.      BorderPtr    = POINTER TO Border;
  207.      Border       = RECORD
  208.        leftEdge   : INTEGER;
  209.        topEdge    : INTEGER;
  210.        frontPen   : SHORTCARD;
  211.        backPen    : SHORTCARD;
  212.        drawMode   : DrawModeSet;
  213.        count      : SHORTCARD;
  214.        xy         : POINTER TO ARRAY[0..255] OF
  215.                       ARRAY[borderX..borderY] OF INTEGER;
  216.        nextBorder : BorderPtr;
  217.      END;
  218.  
  219.  
  220. (* 'MenuHandlePtr' wird bei einem Aufruf von 'InitMenu' übergeben und   *)
  221. (* muß bei fast allen Menüoperationen mit angegeben werden. Durch den   *)
  222. (* 'MenuHandle' ist es möglich, mehrere Menus in verschiedenen Fenstern *)
  223. (* zur gleichen Zeit zu bearbeiten.                                     *)
  224.  
  225.      MenuHandlePtr = POINTER TO MenuHandle;
  226.      MenuHandle = RECORD
  227.        window      : WindowPtr;      (* public *)
  228.        main        : MenuPtr;
  229.  
  230.        widthCheck  : INTEGER;        (* private *)
  231.        widthCom    : INTEGER;
  232.        made        : MadeSet;
  233.        defHeight   : INTEGER;
  234.        defWidthAdd : INTEGER;
  235.        defXOffset  : INTEGER;
  236.        defYSpace   : INTEGER;
  237.        defXSpace   : INTEGER;
  238.        xItem       : INTEGER;
  239.        xSubItem    : INTEGER;
  240.        actMenus    : INTEGER;
  241.        actItems    : INTEGER;
  242.        actSubItems : INTEGER;
  243.        topItem     : INTEGER;
  244.        topSub      : INTEGER;
  245.        exclude     : BOOLEAN;
  246.        exPauseItem : BOOLEAN;
  247.        exPauseSub  : BOOLEAN;
  248.        exItem      : BOOLEAN;
  249.        exSubItem   : BOOLEAN;
  250.        exSetItem   : LONGSET;
  251.        exSetSub    : LONGSET;
  252.        defFontAttr : TextAttr;
  253.        actFontAttr : TextAttrPtr;
  254.        fontAttr    : NewRememberPtr;
  255.        defFontName : POINTER TO ARRAY[0..31] OF CHAR;
  256.        defFont     : TextFontPtr;
  257.        actFont     : TextFontPtr;
  258.        actMenu     : MenuPtr;
  259.        actItem     : MenuItemPtr;
  260.        actSubItem  : MenuItemPtr;
  261.        startItem   : MenuItemPtr;
  262.        startSub    : MenuItemPtr;
  263.      END;
  264.  
  265.  
  266. (* 'GadgetHandlePtr' wird bei einem Aufruf von 'InitGadgetList' zurück- *)
  267. (* gegeben. Dieser wird benötigt, um Gadgets in ein bestimmtes Window   *)
  268. (* einzusetzen. Es können keine Gadgets ohne diesen 'GadgetHandle'      *)
  269. (* erzeugt werden.                                                      *)
  270.  
  271.      GadgetHandlePtr = POINTER TO GadgetHandle;
  272.      GadgetHandle    = RECORD
  273.        window        : WindowPtr;        (* public *)
  274.        requester     : RequesterPtr;
  275.        gadgets       : NewRememberPtr;   (* private *)
  276.        defFontAttr   : TextAttr;
  277.        actFontAttr   : TextAttrPtr;
  278.        fontAttr      : NewRememberPtr;
  279.        defFontName   : POINTER TO ARRAY[0..31] OF CHAR;
  280.        defFont       : TextFontPtr;
  281.        actFont       : TextFontPtr;
  282.      END;
  283.  
  284.  
  285. (* 'Gadgets' (bzw. 'GadgetsPtr') ist eine Struktur, die bei der         *)
  286. (* Erzeugung jeder Art von Gadget benutzt wird. Der Benutzer kann       *)
  287. (* nachträglich auf alle Elemente zugreifen. Es wäre allerdings besser  *)
  288. (* die folgenden Routinen dazu benutzen um die Kompatibilität zu        *)
  289. (* bewahren und Fehlfunktionen zu vermeiden.                            *)
  290.  
  291.      GadgetsPtr      = POINTER TO Gadgets;
  292.      Gadgets         = RECORD
  293.        gadget        : Gadget;
  294.        handler       : GadgetHandlePtr;
  295.        CASE type     : GadgetType OF
  296.        |boolean      :
  297.          bool        : BoolInfo;
  298.          data        : ADDRESS;
  299.          text        : ADDRESS;
  300.          pad0        : ARRAY[0..8] OF INTEGER;
  301.        |proport      :
  302.          prop        : PropInfo;
  303.          xi,yi       : CARDINAL;
  304.          xm,ym       : CARDINAL;
  305.          pad1        : ARRAY[0..2] OF INTEGER;
  306.        ELSE
  307.          str         : StringInfo;
  308.        END;
  309.      END;
  310.  
  311.  
  312.  
  313. (* 'CreateScreen' öffnet einen Bildschirm mit der Breite 'width' und    *)
  314. (* der Höhe 'height', sowie 'depth' Bitplanes. 'title' sollte eine      *)
  315. (* Adresse auf eine(n) String(konstante) enthalten. 'detailPen' ist     *)
  316. (* die Farbe der Schrift in der Screenleiste und 'blockPen' der der     *)
  317. (* Leiste selbst. 'type' gibt den Art des Bildschirms an. 'viewModes'   *)
  318. (* enthält die Art der Bildschirmdarstellung ('lace','hires',...).      *)
  319. (* 'defFont' zeigt, wenn gewünscht, auf einen TextAttr, der den         *)
  320. (* Standartfont für den Screen enthält. Wenn der Workbenchfont          *)
  321. (* gewünscht wird ist hier NIL einzutragen.                             *)
  322.  
  323. PROCEDURE CreateScreen(width,height : INTEGER;
  324.                        depth        : INTEGER;
  325.                        title        : ADDRESS;
  326.                        detailPen    : SHORTINT;
  327.                        blockPen     : SHORTINT;
  328.                        type         : ScreenFlagSet;
  329.                        viewModes    : ViewModeSet;
  330.                        defFont      : TextAttrPtr) : ScreenPtr;
  331.  
  332.  
  333.  
  334. (* 'CreateSimpleScreen' öffnet einen Screen ohne so viele Daten wie     *)
  335. (* in 'CreateScreen' angeben zu müssen. Die ersten vier Argumente       *)
  336. (* entsprechen denen aus 'CreateScreen'. 'mode' gibt den Bildschirm-    *)
  337. (* Modus an. 'mode' kann die folgenden Werte besitzen :                 *)
  338. (* '1'    : LoRes - NonInterlaced                                       *)
  339. (* '2'    : HiRes - NonInterlaced                                       *)
  340. (* '3'    : LoRes - Interlaced                                          *)
  341. (* '4'    : HiRes - Interlaced                                          *)
  342. (* Diese Werte entsprechen denen aus AmigaBasics Screen-Befehl.         *)
  343. (* Der Screen wird dann als Customscreen geöffnet mit detailPen=0 und   *)
  344. (* blockPen=1 sowie dem Standartfont der Workbench.                     *)
  345.  
  346. PROCEDURE CreateSimpleScreen(width,height : INTEGER;
  347.                              depth        : INTEGER;
  348.                              title        : ADDRESS;
  349.                              mode         : INTEGER) : ScreenPtr;
  350.  
  351.  
  352.  
  353. (* 'DeleteScreen' löscht einen mit 'CreateScreen' oder                  *)
  354. (* 'CreateSimpleScreen' erstellten Screen.                              *)
  355.  
  356. PROCEDURE DeleteScreen(VAR screen : ScreenPtr);
  357.  
  358.  
  359.  
  360. (* 'CreateWindow' öffnet ein Window mit den Koordinaten 'x','y' und     *)
  361. (* der in 'width' und 'height' angegebenen Breite und Höhe. 'minWidth'  *)
  362. (* und 'minHeight' geben bei Sizing-Windows die minimale Größe des      *)
  363. (* Fensters wieder, während 'maxWidth' und 'maxHeight' die maximale.    *)
  364. (* 'title', sowie 'detailPen' und 'blockPen' entsprechen denen aus      *)
  365. (* 'CreateScreen'. 'gadgets' geben, wenn gewünscht, eine Liste von      *)
  366. (* einzubindenen Gadgets an. Hierbei ist zu beachten, daß wenn die      *)
  367. (* Gadgets mit diesen Befehlen erstellt wurden etwas zu beachten ist.   *)
  368. (* Bei einem 'gimmeZeroZero'-Window muß das Flag 'gzzGadget' in alle    *)
  369. (* Gadgets von Hand eingebunden werden! 'idcmpFlags' geben an, auf      *)
  370. (* welche Arten von Nachrichten reagiert werden soll. 'flags'           *)
  371. (* bestimmen das Aussehen und die Funktionalität des Windows.           *)
  372. (* 'screenFlags' enthält bei eigenen Customscreens den Wert             *)
  373. (* 'customScreen', während Workbenchwindows hier 'wbenchScreen'         *)
  374. (* eintragen müssen. 'screen' ist entweder NIL für Workbenchwindows     *)
  375. (* oder für Windows auf anderen Screens gleich dem Zeiger auf die       *)
  376. (* Screenstruktur.                                                      *)
  377.  
  378. PROCEDURE CreateWindow(x,y                : INTEGER;
  379.                        width,height       : INTEGER;
  380.                        minWidth,minHeight : INTEGER;
  381.                        maxWidth,maxHeight : INTEGER;
  382.                        title              : ADDRESS;
  383.                        detailPen          : SHORTINT;
  384.                        blockPen           : SHORTINT;
  385.                        gadgets            : GadgetPtr;
  386.                        idcmpFlags         : IDCMPFlagSet;
  387.                        flags              : WindowFlagSet;
  388.                        screenFlags        : ScreenFlagSet;
  389.                        screen             : ScreenPtr) : WindowPtr;
  390.  
  391.  
  392.  
  393. (* 'CreateSimpleWindow' öffnet ein einfacher zu startendes Window, mit  *)
  394. (* weniger Parametern. Die Parameter hier entsprechen denen aus         *)
  395. (* 'CreateWindow' vollkommen. Es wird ein Fenster geöffnet mit          *)
  396. (* detailPen=0 und blockPen=1, sowie oft benötigte IDCMPFlags. Die      *)
  397. (* minimale Windowgröße beträgt (80,40) und es gibt keine maximale      *)
  398. (* Größe des Window.                                                    *)
  399.  
  400. PROCEDURE CreateSimpleWindow(x,y          : INTEGER;
  401.                              width,height : INTEGER;
  402.                              title        : ADDRESS;
  403.                              flags        : WindowFlagSet;
  404.                              screen       : ScreenPtr) : WindowPtr;
  405.  
  406.  
  407.  
  408. (* 'DeleteWindow' entfernt ein mittels 'CreateWindow' oder              *)
  409. (* 'CreateSimpleWindow' geöffnetes Fenster.                             *)
  410.  
  411. PROCEDURE DeleteWindow(VAR window : WindowPtr);
  412.  
  413.  
  414.  
  415. (* 'InclIDCMPFlags' fügt dem Window auf kompatiblen Weg neue IDCMP-     *)
  416. (* Flags hinzu.                                                         *)
  417.  
  418. PROCEDURE InclIDCMPFlag(window : WindowPtr;
  419.                         idcmp  : IDCMPFlags);
  420.  
  421.  
  422.  
  423. (* 'ExclIDCMPFlags' entfernt auf kompatiblen Weg IDCMP-Flags aus dem    *)
  424. (* Window. Alle in 'idcmp' angegebenen Flags werden im Window gelöscht. *)
  425.  
  426. PROCEDURE ExclIDCMPFlag(window : WindowPtr;
  427.                         idcmp  : IDCMPFlags);
  428.  
  429.  
  430.  
  431. (* 'GetImage' schneidet aus dem angegebenen Rastport eine Grafik heraus *)
  432. (* die sich an der Position ('x','y') befindet und die Größe 'w'*'h'    *)
  433. (* besitzt. Das Image kann kann in ein Menu oder Gadget eingebunden     *)
  434. (* werden, oder aber direkt mittels Intuitions 'DrawImage' in ein       *)
  435. (* RastPort gezeichnet werden. 'if' weist auf eine Imagestruktur, die   *)
  436. (* mit der neuen verkettet werden soll. Die neue Struktur wird hinter   *)
  437. (* (!) die 'if' Struktur gesetzt. Wenn keine Images verkettet werden    *)
  438. (* sollen, muß hier NIL angegeben werden. Ansonsten wird das Image      *)
  439. (* an die Struktur 'if' angekettet und auch 'if' zurückgegeben.         *)
  440. (* Das Image wird bei DrawImage oder ähnlichen Aufrufen auf die dazu    *)
  441. (* relativen Koordinaten 'dx' und 'dy' gesetzt.                         *)
  442.  
  443. PROCEDURE GetImage(rp    : RastPortPtr;
  444.                    x,y   : INTEGER;
  445.                    w,h   : INTEGER;
  446.                    dx,dy : INTEGER;
  447.                    if    : ImagePtr) : ImagePtr;
  448.  
  449.  
  450.  
  451. (* 'SaveImage' speichert das zu übergebene Image in ein File, das       *)
  452. (* mittels dem Modul FileSystem geöffnet worden sein muß.               *)
  453.  
  454. PROCEDURE SaveImage(VAR fh : File;
  455.                     image  : ImagePtr);
  456.  
  457.  
  458.  
  459. (* 'LoadImage' lädt ein Image aus einem File, das mittels 'SaveImage'   *)
  460. (* in das jeweilige File geschrieben wurde.                             *)
  461.  
  462. PROCEDURE LoadImage(VAR fh : File;
  463.                     if     : ImagePtr) : ImagePtr;
  464.  
  465.  
  466.  
  467. (* 'GetColorImage' gibt ein einfarbiges Image zurück, das keinerlei     *)
  468. (* Daten für das Aussehen des Bildes verbraucht.                        *)
  469.  
  470. PROCEDURE GetColorImage(w,h   : INTEGER;
  471.                         dx,dy : INTEGER;
  472.                         color : INTEGER;
  473.                         if    : ImagePtr) : ImagePtr;
  474.  
  475.  
  476.  
  477. (* 'FreeImage' gibt ein mittels 'GetImage', 'GetColorImage' oder        *)
  478. (* 'LoadImage' erzeugtes Bild an das System zurück.                     *)
  479.  
  480. PROCEDURE FreeImage(VAR image : ImagePtr);
  481.  
  482.  
  483.  
  484. (* 'FreeImageList' gibt eine verkette Liste von Images frei. Es wird    *)
  485. (* für jedes Image der Liste 'FreeImage' aufgerufen.                    *)
  486.  
  487. PROCEDURE FreeImageList(VAR image : ImagePtr);
  488.  
  489.  
  490.  
  491. (* 'GetBorder' belegt Speicher für eine Borderstruktur sowie dessen     *)
  492. (* Daten. Es wird Platz belegt für 'c' Koordinatenpaare. Um z.B.        *)
  493. (* ein Rechteck zu erzeugen, benötigt man 5 Paare (Start und Endpunkt   *)
  494. (* sollten die selben sein, damit der Rahmen geschlossen ist!).         *)
  495. (* 'fp' ist die Farbe des FrontPens und 'bp' die Farbe des BackPens.    *)
  496. (* 'bf' ist ein Zeiger auf einee Borderstruktur, mit der die neue       *)
  497. (* verkettet werden soll. Wenn keine verkettet werden sollen, muß NIL   *)
  498. (* übergeben werden.                                                    *)
  499.  
  500. PROCEDURE GetBorder(fp,bp : INTEGER;
  501.                     dm    : DrawModeSet;
  502.                     c     : SHORTCARD;
  503.                     bf    : BorderPtr) : BorderPtr;
  504.  
  505.  
  506.  
  507. (* 'SetBorderOutline' kopiert aus einer Adresse die Koordinaten des     *)
  508. (* Borders heraus. Man kann also die Borderdaten in einer ASSEMBLE      *)
  509. (* Prozedur ablegen (DC.W x,y) und sie mit diesem Befehl dem Border     *)
  510. (* zuweisen.                                                            *)
  511.  
  512. PROCEDURE SetBorderOutline(b    : BorderPtr;
  513.                            data : ADDRESS);
  514.  
  515.  
  516.  
  517. (* 'GetRectBorder' besorgt ein rechteckigen Border. Da meistens nur     *)
  518. (* rechteckige Border benutzt werden, ist diese Funktion implementiert  *)
  519. (* um einfach einen Rechtecksborder erzeugen zu können.                 *)
  520.  
  521. PROCEDURE GetRectBorder(fp,bp       : INTEGER;
  522.                         dm          : DrawModeSet;
  523.                         x1,y1,x2,y2 : INTEGER;
  524.                         bf          : BorderPtr) : BorderPtr;
  525.  
  526.  
  527.  
  528. (* 'NewGetRectBorder' besorgt ein (in Wirklichkeit zwei) Border-        *)
  529. (* strukturen, die im Kickstart 2.0 Look aufgebaut sind. Dabei          *)
  530. (* entspricht 'fp' die Farbe der linken, oberen Ecke und 'bp' die Farbe *)
  531. (* der unteren, rechten Ecke. Mit 'NewGetRectBorder' beschaffte Border  *)
  532. (* müssen mittels 'FreeBorderList' freigegeben werden!                  *)
  533.  
  534. PROCEDURE NewGetRectBorder(fp,bp       : INTEGER;
  535.                            dm          : DrawModeSet;
  536.                            x1,y1,x2,y2 : INTEGER;
  537.                            bf          : BorderPtr) : BorderPtr;
  538.  
  539.  
  540.  
  541. (* 'FreeBorder' gibt ein mittels 'GetBorder' oder 'GetRectBorder'       *)
  542. (* belegten Border wieder an das System zurück.                         *)
  543.  
  544. PROCEDURE FreeBorder(VAR b : BorderPtr);
  545.  
  546.  
  547.  
  548. (* 'FreeBorderList' gibt eine verkettete Liste von Borders frei, die    *)
  549. (* mittels den '..Get..Border'-Befehlen belegt wurden.                  *)
  550.  
  551. PROCEDURE FreeBorderList(VAR b : BorderPtr);
  552.  
  553.  
  554.  
  555. (* 'AddIntuiText' gibt dem Benutzer ein IntuiText zurück, der mit den   *)
  556. (* übergebenen Werten gefüllt wird. 'xr' und 'yr' sind die relativen(!) *)
  557. (* Koordinaten bei der Textausgabe. 'fp', 'bp' und 'dm' entsprechen     *)
  558. (* denen aus 'GetBorder'. 'font' zeigt, wenn gewünscht, auf einen       *)
  559. (* TextAttr der die gewünschte Schriftart enthält. Wenn die Standart-   *)
  560. (* schrift gewünscht ist, muß NIL übergeben werden.                     *)
  561. (* IntuiTexts werden hier bei der Ausstattung von Requestern benötigt.  *)
  562. (* Durch Angabe eines Vorgängers des IntuiTexts kann durch Angabe       *)
  563. (* des Vorgängers in 'fit' bewirkt werden, daß diese IntuiTexte         *)
  564. (* zu einer Kette verknüpft werden.                                     *)
  565.  
  566. PROCEDURE AddIntuiText(xr,yr  : INTEGER;
  567.                        fp,bp  : SHORTCARD;
  568.                        dm     : DrawModeSet;
  569.                        font   : TextAttrPtr;
  570.                        text   : ARRAY OF CHAR;
  571.                        fit    : IntuiTextPtr) : IntuiTextPtr;
  572.  
  573.  
  574.  
  575. (* 'FreeIntuiText' gibt den mittels 'GetIntuiText' belegten Speicher    *)
  576. (* einer IntuiText-Struktur wieder frei.                                *)
  577.  
  578. PROCEDURE FreeIntuiText(VAR it : IntuiTextPtr);
  579.  
  580.  
  581.  
  582. (* 'FreeIntuiTextList' gibt eine verkette Liste von IntuiTexten frei,   *)
  583. (* die mittels dem Befehl AddIntuiText verknüpft wurden. Es wird der    *)
  584. (* Zeiger auf das erste Element erwartet.                               *)
  585.  
  586. PROCEDURE FreeIntuiTextList(VAR fit : IntuiTextPtr);
  587.  
  588.  
  589.  
  590. (* 'GetMenu' liefert die Adresse des Menus zurück mit 'menuNr' als      *)
  591. (* Nummer des Menus (von 0 beginnend).                                  *)
  592.  
  593. PROCEDURE GetMenu(mh     : MenuHandlePtr;
  594.                   menuNr : INTEGER) : MenuPtr;
  595.  
  596.  
  597.  
  598. (* 'GetItem' liefert die Adresse der MenuItem-Struktur des Items zurück *)
  599. (* das sich an 'itemNr' Stelle des Menus befindet.                      *)
  600.  
  601. PROCEDURE GetItem(menu   : MenuPtr;
  602.                   itemNr : INTEGER) : MenuItemPtr;
  603.  
  604.  
  605.  
  606. (* 'GetSubItem' arbeitet genauso wie 'GetItem' nur wird die Adresse     *)
  607. (* eines Subitems (wenn möglich) ermittelt.                             *)
  608.  
  609. PROCEDURE GetSubItem(menuItem  : MenuItemPtr;
  610.                      subItemNr : INTEGER) : MenuItemPtr;
  611.  
  612.  
  613. (* 'GetMenuItem' ist eine Zusammenfassung der vorhergehenden Get...-    *)
  614. (* Befehle. Es wird gleich der Zeiger auf ein (Sub)MenuItem zurück-     *)
  615. (* gegeben, das sich an der spezifizierten Stelle befindet. Wenn ein    *)
  616. (* MenuItem gesucht ist, muß in 'subItemNr' ein -1 übergeben werden.    *)
  617.  
  618. PROCEDURE GetMenuItem(mh                      : MenuHandlePtr;
  619.                       menuNr,itemNr,subItemNr : INTEGER) : MenuItemPtr;
  620.  
  621.  
  622.  
  623. (* 'GetItemNumber' arbeitet genau entgegengesetzt zu 'GetMenuItem'. Es  *)
  624. (* wird zu einem gegebenen Item die Position im Menu bestimmt. Wenn     *)
  625. (* das Item kein Subitem ist, wird in 'subItemNr' eine -1 zurückgegeben.*)
  626.  
  627. PROCEDURE GetItemNumber(mh : MenuHandlePtr;
  628.                         it : MenuItemPtr;
  629.                         VAR menuNr,itemNr,subItemNr : INTEGER);
  630.  
  631.  
  632.  
  633. (* 'SetDefaultMenuFont' setzt als Schriftart den bei InitMenu ange-     *)
  634. (* gebenen Font ein, um die nächsten Items in derjenigen Schriftart     *)
  635. (* darzustellen.                                                        *)
  636.  
  637. PROCEDURE SetDefaultMenuFont(mh : MenuHandlePtr);
  638.  
  639.  
  640.  
  641. (* 'SetMenuFont' setzt eine neue Schriftart ein, um die nächsten Items  *)
  642. (* in dieser Schriftart darzustellen. 'font' enthält den Namen des      *)
  643. (* Fonts ohne die Endung '.font'! Wenn der Font geladen werden konnte,  *)
  644. (* wird ein TRUE zurückgegeben, ansonsten ein FALSE. Wenn die           *)
  645. (* angegebene Höhe nicht verfügbar ist, wird versucht die nächst-       *)
  646. (* liegende Größe zu öffnen.                                            *)
  647.  
  648. PROCEDURE SetMenuFont(mh     : MenuHandlePtr;
  649.                       font   : ARRAY OF CHAR;
  650.                       height : CARDINAL;
  651.                       styles : FontStyleSet) : BOOLEAN;
  652.  
  653.  
  654.  
  655. (* 'InitMenu' initialisiert eine MenuHandle-Struktur, die der Benutzer  *)
  656. (* zurückbekommt. 'window' spezifiziert das Fenster in dem das Menu     *)
  657. (* dargestellt werden soll. Die anderen Größen entsprechen denen aus    *)
  658. (* 'SetMenuFont'. Um Topaz 8 zu öffnen, können die Konstanten 'stdFont' *)
  659. (* und 'stdHeight' benutzt werden. Wenn der angegebene Font nicht       *)
  660. (* gefunden werden konnte, wird Topaz 8 benutzt.                        *)
  661.  
  662. PROCEDURE InitMenu(window       : WindowPtr;
  663.                    standardFont : ARRAY OF CHAR;
  664.                    height       : CARDINAL;
  665.                    styles       : FontStyleSet) : MenuHandlePtr;
  666.  
  667.  
  668.  
  669. (* 'AddMenu' fügt ein Menupunkt in der Titelleiste hinzu. 'enable'      *)
  670. (* bestimmt, ob der komplette Menupunkt (auch seine Items) anwählbar    *)
  671. (* sind (TRUE) oder nicht (FALSE). Hierzu können auch die Konstanten    *)
  672. (* 'enabled' und 'disabled' benutzt werden.                             *)
  673.  
  674. PROCEDURE AddMenu(mh     : MenuHandlePtr;
  675.                   name   : ARRAY OF CHAR;
  676.                   enable : BOOLEAN);
  677.  
  678.  
  679.  
  680. (* 'SetDefaultHeight' setzt den Zwischenraum zwischen zwei Items fest.  *)
  681. (* Dieser wird in Punkten angegeben. (Voreingestellt : 2 Punkte)        *)
  682.  
  683. PROCEDURE SetDefaultHeight(mh     : MenuHandlePtr;
  684.                            height : INTEGER);
  685.  
  686.  
  687.  
  688. (* 'SetDefaultAdditionalWidth' legt die zusätzliche Breite der Menu-    *)
  689. (* punkte in der Titelleiste, der Items und Subitems fest. Diese kann   *)
  690. (* nur für ein (Sub)Menu komplett aktiv sein. Es gilt der Wert bei      *)
  691. (* Begin eines neuen Menu(punkte)s. (Voreingestellt : 24 Punkte)        *)
  692.  
  693. PROCEDURE SetDefaultAdditionalWidth(mh  : MenuHandlePtr;
  694.                                     add : INTEGER);
  695.  
  696.  
  697.  
  698. (* Mit 'SetXOffset' kann man die Items noch zusätzlich horizontal ver-  *)
  699. (* schieben, wobei allerdings darauf geachtet werden muß, daß das Item  *)
  700. (* (auch nicht teilweise) außerhalb der Menutafel gerät! Es können hier *)
  701. (* die Konstanten 'standart' und 'center' benutzt werden. 'standart'    *)
  702. (* setzt die Voreinstellung (0 Punkte) und 'center' zentriert den Text  *)
  703. (* zwischen der Breite des 'AdditionalWidth'.                           *)
  704.  
  705. PROCEDURE SetXOffset(mh     : MenuHandlePtr;
  706.                      offset : INTEGER);
  707.  
  708.  
  709.  
  710. (* 'SetDefaultYSpace' gibt an wieviel Punkte zwischen zwei MenuItems    *)
  711. (* noch zusätzlich frei bleiben sollen. (Voreinstellung : 2 Punkte)     *)
  712.  
  713. PROCEDURE SetDefaultYSpace(mh    : MenuHandlePtr;
  714.                            space : INTEGER);
  715.  
  716.  
  717.  
  718. (* 'SetDefaultXSpace' gibt an wieviel Punkte bei Start einer neuen      *)
  719. (* Spalte noch zusätzlich freigemacht werden sollen. (Voreinstellung :  *)
  720. (* 0 Punkte)                                                            *)
  721.  
  722. PROCEDURE SetDefaultXSpace(mh    : MenuHandlePtr;
  723.                            space : INTEGER);
  724.  
  725.  
  726.  
  727. (* 'StartMutualExclude' markiert den Anfang eines Mutual-Exclude        *)
  728. (* Bereiches. Von Mutual-Exclude (Gegenseitiger Ausschluß) spricht man, *)
  729. (* wenn bei einer Einschaltung eines Toggle Schalters, bestimmte andere *)
  730. (* Schalter damit gleichzeitig ausgeschaltet werden, so daß in einem    *)
  731. (* bestimmten Bereich nur ein eingeschalteter Schalter existieren kann. *)
  732. (* Wenn mehrere 'checkit'-Menuitems so gesetzt werden sollen, daß immer *)
  733. (* nur einer von ihnen angewählt seien kann, sollten diese Befehle      *)
  734. (* benutzt werden. Man könnte sich zum Beispiel eine Farbauswahl denken *)
  735. (* von der natürlich immer nur eine Farbe selektiert sein kann.         *)
  736.  
  737. PROCEDURE StartMutualExclude(mh : MenuHandlePtr);
  738.  
  739.  
  740.  
  741. (* 'PauseMutualExclude' pausiert das Mutual-Exclude-Verfahren für die   *)
  742. (* nächsten Items, bis 'EndPauseMutualExclude' aufgerufen wird.         *)
  743.  
  744. PROCEDURE PauseMutualExclude(mh : MenuHandlePtr);
  745.  
  746.  
  747.  
  748. (* 'EndPauseMutualExclude' beendet ein Aussetzen des Mutual-Excludes    *)
  749. (* durch den Befehl 'PauseMutualExclude'                                *)
  750.  
  751. PROCEDURE EndPauseMutualExclude(mh : MenuHandlePtr);
  752.  
  753.  
  754.  
  755. (* 'EndMutualExclude' markiert das Ende des Mutual-Exclude Bereichs.    *)
  756.  
  757. PROCEDURE EndMutualExclude(mh : MenuHandlePtr);
  758.  
  759.  
  760.  
  761. (* 'AddTextMenuItem' fügt ein MenuItem zu dem aktuellen Menu hinzu.     *)
  762. (* Im Menu erscheint der Text 'text'. Während der Mauspfeil sich        *)
  763. (* über dem Item befindet wird der Text 'sel' angezeigt. Nur wenn 'sel' *)
  764. (* 'none' ist, wird auf andere Modis wie z.B. 'box' oder 'invert' in    *)
  765. (* 'flags' geprüft. 'cut' ist ein Shortcut für das MenuItem. Wenn 'cut' *)
  766. (* gleich 'none' ist, wird kein Shortcut angegeben.                     *)
  767.  
  768. PROCEDURE AddTextMenuItem(mh     : MenuHandlePtr;
  769.                           text   : ARRAY OF CHAR;
  770.                           sel    : ARRAY OF CHAR;
  771.                           cut    : CHAR;
  772.                           flags  : ItemFlagSet);
  773.  
  774.  
  775.  
  776. (* 'AddBarMenuItem' fügt einen Balken in die MenuItems ein, der nicht   *)
  777. (* anwählbar ist und eine Strukturierung des Menuaufbaus ermöglichen    *)
  778. (* soll. Die Breite des Balkens wird automatisch angepaßt.              *)
  779.  
  780. PROCEDURE AddBarMenuItem(mh   : MenuHandlePtr);
  781.  
  782.  
  783.  
  784. (* 'AddImageMenuItem' ist mit 'AddTextMenuItem' vergleichbar, nur wird  *)
  785. (* hier ein Image in den Menuaufbau mit hereingenommen. Um hier kein    *)
  786. (* zweites Image anzuzeigen, wenn sich der Mauspfeil über dem Item      *)
  787. (* befindet, muß 'sel' auf 'noImage' (bzw. NIL) gesetzt werden.         *)
  788.  
  789. PROCEDURE AddImageMenuItem(mh     : MenuHandlePtr;
  790.                            image  : ImagePtr;
  791.                            sel    : ImagePtr;
  792.                            cut    : CHAR;
  793.                            flags  : ItemFlagSet);
  794.  
  795.  
  796.  
  797. (* Für 'AddTextSubItem' gilt das gleiche wie für 'AddTextItem' nur wird *)
  798. (* stattdessen ein weiterer Untermenupunkt erzeugt.                     *)
  799.  
  800. PROCEDURE AddTextSubItem(mh     : MenuHandlePtr;
  801.                          text   : ARRAY OF CHAR;
  802.                          sel    : ARRAY OF CHAR;
  803.                          cut    : CHAR;
  804.                          flags  : ItemFlagSet);
  805.  
  806.  
  807.  
  808. (* Für 'AddBarSubItem' gilt das gleiche, daß unter 'AddBarMenuItem'     *)
  809. (* gesagt wurde.                                                        *)
  810.  
  811. PROCEDURE AddBarSubItem(mh   : MenuHandlePtr);
  812.  
  813.  
  814.  
  815. (* 'AddImageSubItem' entspricht 'AddImageItem' nur wird ein Submenu     *)
  816. (* angehängt.                                                           *)
  817.  
  818. PROCEDURE AddImageSubItem(mh     : MenuHandlePtr;
  819.                           image  : ImagePtr;
  820.                           sel    : ImagePtr;
  821.                           cut    : CHAR;
  822.                           flags  : ItemFlagSet);
  823.  
  824.  
  825.  
  826. (* 'StartNewColomn' fängt eine neue Spalte an. So ist es möglich        *)
  827. (* mehrere Menüpunkte auch nebeneinander aufzubauen.                    *)
  828.  
  829. PROCEDURE StartNewColumn(mh : MenuHandlePtr);
  830.  
  831.  
  832.  
  833. (* 'InstallMenu' installiert das erzeugte Menu in dem in 'InitMenu'     *)
  834. (* festgelegten Window. Wenn es erfolgreich verlief, wird TRUE zurück-  *)
  835. (* gegeben, ansonsten FALSE.                                            *)
  836.  
  837. PROCEDURE InstallMenu(mh : MenuHandlePtr) : BOOLEAN;
  838.  
  839.  
  840.  
  841. (* 'FreeMenu' entfernt ein Menu von dem Window und gibt alle belegten   *)
  842. (* Strukturen wieder frei.                                              *)
  843.  
  844. PROCEDURE FreeMenu(VAR mh : MenuHandlePtr);
  845.  
  846.  
  847.  
  848. (* 'MenuItemChecked' fragt ab, ob ein bestimmtes (Sub)MenuItem          *)
  849. (* angeschaltet ist. Dieses ist natürlich nur mit den 'checkit' bzw.    *)
  850. (* 'checkset' Items möglich. Es wird TRUE zurückgegeben, wenn das       *)
  851. (* Item angeschaltet ist, also mit einem Häkchen markiert ist.          *)
  852.  
  853. PROCEDURE MenuItemChecked(mh                      : MenuHandlePtr;
  854.                           menuNr,itemNr,subItemNr : INTEGER) : BOOLEAN;
  855.  
  856.  
  857.  
  858. (* 'MenuEnable' kann ein ganzes Menu ein- bzw. ausschalten. Nach        *)
  859. (* Abschalten des Menus kann kein (Sub)Item des Menus mehr angewählt    *)
  860. (* werden. Wenn 'enable' 'enabled' (TRUE) ist wird das Menu einge-      *)
  861. (* schaltet, bei 'disabled' (FALSE) ausgeschaltet.                      *)
  862.  
  863. PROCEDURE MenuEnable(mh     : MenuHandlePtr;
  864.                      menuNr : INTEGER;
  865.                      enable : BOOLEAN);
  866.  
  867.  
  868.  
  869. (* Für 'MenuItemEnable' gilt das gleiche, wie unter 'MenuEnable' gesagt *)
  870. (* nur betrifft es hier nur ein einzelnes Item.                         *)
  871.  
  872. PROCEDURE MenuItemEnable(mh                  : MenuHandlePtr;
  873.                          menuNr,itemNr,subNr : INTEGER;
  874.                          enable              : BOOLEAN);
  875.  
  876.  
  877.  
  878. (* 'ModifyMenu' verändert nachträglich die Daten eines Menupunktes. Es  *)
  879. (* werden die gleichen Parameter wie bei 'AddMenu' übergeben. Es ist    *)
  880. (* darauf zu achten, daß der neue Name nicht länger ist als der alte!!! *)
  881.  
  882. PROCEDURE ModifyMenu(mh     : MenuHandlePtr;
  883.                      menuNr : INTEGER;
  884.                      name   : ARRAY OF CHAR;
  885.                      enable : BOOLEAN);
  886.  
  887.  
  888.  
  889. (* 'ModifyTextItem' benutzt die gleichen Parameter wie 'AddTextItem'.   *)
  890. (* Es werden nachträglich Daten des Menupunktes geändert. Es ist darauf *)
  891. (* zu achten, daß die neuen Texte nicht länger sind als die alten!!!    *)
  892.  
  893. PROCEDURE ModifyTextItem(mh                  : MenuHandlePtr;
  894.                          menuNr,itemNr,subNr : INTEGER;
  895.                          text                : ARRAY OF CHAR;
  896.                          sel                 : ARRAY OF CHAR;
  897.                          flags               : ItemFlagSet);
  898.  
  899.  
  900.  
  901. (* 'ModifyImageItem' benutzt die gleichen Parameter wie 'AddImageItem'. *)
  902. (* Es werden nachträglich die Daten des Items geändert. Es ist darauf   *)
  903. (* zu achten, daß die neuen Images nicht größer sind als die neuen bzw. *)
  904. (* einen anderen Typ besitzen (Images-ColorImages)!!!!                  *)
  905.  
  906. PROCEDURE ModifyImageItem(mh                  : MenuHandlePtr;
  907.                           menuNr,itemNr,subNr : INTEGER;
  908.                           image               : ImagePtr;
  909.                           sel                 : ImagePtr;
  910.                           flags               : ItemFlagSet);
  911.  
  912.  
  913.  
  914. (* 'WaitForPossibleAction' setzt den Task solange in den Wartezustand   *)
  915. (* bis das System eine Nachricht sendet. Es wird ein 'MessageType'      *)
  916. (* zurückgegeben, worin vermerkt ist, um welche Art von Nachricht es    *)
  917. (* sich handelt. Zusätzlich wird in 'idcmp' der genaue Auslöser fest-   *)
  918. (* gehalten. Nach diesem Befehl kann die Nachricht entweder durch       *)
  919. (* den Befehl 'GetMenuSelection', 'GetGadgetSelection' oder             *)
  920. (* 'GetIntuiMessage' ausgelesen werden.                                 *)
  921.  
  922. PROCEDURE WaitForPossibleAction(win       : WindowPtr;
  923.                                 VAR idcmp : IDCMPFlagSet) : MessageType;
  924.  
  925.  
  926.  
  927. (* 'GetMenuSelection besorgt sich die Nummer des Items das ausgewählt   *)
  928. (* wurde. Wenn kein Menu angewählt wurde, wird in allen Nummern-        *)
  929. (* Variablen eine -1 zurückgegeben. Wenn es sich um ein normales Item   *)
  930. (* handelt, wird in 'subNr' eine 15 zurückgegeben!                      *)
  931.  
  932. PROCEDURE GetMenuSelection(win                     : WindowPtr;
  933.                            VAR menuNr,itemNr,subNr : INTEGER);
  934.  
  935.  
  936.  
  937. (* 'GetIDGadget' besorgt den Zeiger auf die Gadgetstruktur bei Angabe   *)
  938. (* der ID-Nummer.                                                       *)
  939.  
  940. PROCEDURE GetIDGadget(gh : GadgetHandlePtr;
  941.                       id : INTEGER) : GadgetsPtr;
  942.  
  943.  
  944.  
  945. (* 'GetGadgetStructure' berechnet den standart GadgetPtr aus dem        *)
  946. (* intern benutzten 'GadgetsPtr'. So können theoretisch auch Ver-       *)
  947. (* änderungen von Hand vorgenommen werden, was allerdings nicht zu      *)
  948. (* empfehlen ist, um die Gadget-Routinen nicht durcheinanderzubringen.  *)
  949.  
  950. PROCEDURE GetGadgetStructure(g : GadgetsPtr) : GadgetPtr;
  951.  
  952.  
  953.  
  954. (* 'SetDefaultGadgetFont' setzt den in 'InitGadgetList' vereinbarten    *)
  955. (* Standartfont, als Font für den Text des nächsten Gadgets (nur        *)
  956. (* Boolean-Gadgets!).                                                   *)
  957.  
  958. PROCEDURE SetDefaultGadgetFont(gh : GadgetHandlePtr);
  959.  
  960.  
  961.  
  962. (* 'SetGadgetFont' setzt einen neuen Font für den Text eines folgenden  *)
  963. (* Boolean-Gadgets.                                                     *)
  964.  
  965. PROCEDURE SetGadgetFont(gh     : MenuHandlePtr;
  966.                         font   : ARRAY OF CHAR;
  967.                         height : CARDINAL;
  968.                         styles : FontStyleSet) : BOOLEAN;
  969.  
  970.  
  971.  
  972. (* 'InitGadgetList' initialisiert eine Liste, in der Gadgets            *)
  973. (* eingetragen werden können. Normalerweise genügt eine Liste für ein   *)
  974. (* Window/Requester vollkommen, nur wenn bestimmte Abgrenzungen von     *)
  975. (* Gadgetgruppen erreicht werden sollen, sollten mehrere Gadgetlisten   *)
  976. (* pro Window/Requester eingesetzt werden. Wie bei 'InitMenu' muß ein   *)
  977. (* Standartfont angegeben werden, der normalerweise bei den Boolean-    *)
  978. (* Gadgets eingesetzt wird. Bei Einbindung von Gadgets sofort bei der   *)
  979. (* Öffnung eines Requesters muß die Gadgetliste mit 'window' und        *)
  980. (* 'requester' gleich NIL initialisiert werden und kann dann in         *)
  981. (* 'GetRequester' eingesetzt werden.                                    *)
  982.  
  983. PROCEDURE InitGadgetList(window       : WindowPtr;
  984.                          requester    : RequesterPtr;
  985.                          standardFont : ARRAY OF CHAR;
  986.                          height       : CARDINAL;
  987.                          styles       : FontStyleSet) : GadgetHandlePtr;
  988.  
  989.  
  990.  
  991. (* 'AddBorderBoolGadget' fügt dem Window/Requester ein Booleangadget    *)
  992. (* an der Position 'x','y' mit der Breite 'w' und der Höhe 'h' hinzu.   *)
  993. (* Jedes Gadget in der Liste MUß eine andere ID-Nummer zur Unter-       *)
  994. (* scheidung besitzen (in 'id'). Bei Bedarf wird ein Border (Rahmen)    *)
  995. (* um das Gadget gezogen, und ebenfalls bei Bedarf noch weitere bei     *)
  996. (* Anwahl des Gadgets. Diese müssen in 'b1' bzw. 'b2' eingetragen       *)
  997. (* werden. Wenn keine Rahmen gewünscht sind, müssen in dem jeweiligen   *)
  998. (* Feld 'noImage' (NIL) eingetragen werden. Es wird ein Text in das     *)
  999. (* Gadget geschrieben mit 'c1' als APen, 'c2' als BPen. Der Text 'txt'  *)
  1000. (* wird passent zu den in 'mode' angegebenen Drawmodes gezeichnet.      *)
  1001. (* Soll kein Text ausgegeben werden, sollte 'mode' auf 'jam1' gesetzt   *)
  1002. (* werden und 'none in 'txt' übergeben werden. Das Gadget ist noch      *)
  1003. (* nicht sofort sichtbar, sondern erst der Einsatz von 'DisplayGadget'  *)
  1004. (* oder 'DisplayAllGadgets' wird das Gadget sichtbar.                   *)
  1005.  
  1006. PROCEDURE AddBorderBoolGadget(gh       : GadgetHandlePtr;
  1007.                               x,y      : INTEGER;
  1008.                               w,h      : INTEGER;
  1009.                               id       : INTEGER;
  1010.                               b1,b2    : BorderPtr;
  1011.                               flags    : BoolGadgetFlagSet;
  1012.                               mode     : DrawModeSet;
  1013.                               c1,c2    : SHORTCARD;
  1014.                               txt      : ARRAY OF CHAR) : GadgetsPtr;
  1015.  
  1016.  
  1017.  
  1018. (* 'AddImageBoolGadget' verhält sich wie 'AddBorderBoolGadget', nur     *)
  1019. (* wird hier statt Borders Images auf den Bildschirm gebracht.          *)
  1020.  
  1021. PROCEDURE AddImageBoolGadget(gh       : GadgetHandlePtr;
  1022.                              x,y      : INTEGER;
  1023.                              w,h      : INTEGER;
  1024.                              id       : INTEGER;
  1025.                              i1,i2    : ImagePtr;
  1026.                              flags    : BoolGadgetFlagSet;
  1027.                              mode     : DrawModeSet;
  1028.                              c1,c2    : SHORTCARD;
  1029.                              txt      : ARRAY OF CHAR) : GadgetsPtr;
  1030.  
  1031.  
  1032.  
  1033. (* 'AddBoolGadgetMask' ermöglicht es eine Anwahlmaske für Boolean-      *)
  1034. (* Gadgets zu erzeugen. Dieses wird z.B. benötigt um ein Boolean-       *)
  1035. (* Gadget in Form eines Stopschildes zu generieren. Das Gadget kann     *)
  1036. (* nur dort angewählt werden, wo in der Maske Bits gesetzt sind.        *)
  1037. (* Die Maske ist eine Bitplane mit der Größe des Gadgets. Sie kann      *)
  1038. (* z.B. in einer ASSEMBLE-Prozedur abgelegt werden.                     *)
  1039.  
  1040. PROCEDURE AddBoolGadgetMask(g    : GadgetsPtr;
  1041.                             mask : ADDRESS);
  1042.  
  1043.  
  1044.  
  1045. (* 'AddPropGadget' fügt ein Proportionalgadget dem Window/Requester     *)
  1046. (* an. Die Parameter 'x' bis 'id' entsprechen den 'Add..BoolGadget'     *)
  1047. (* Funktionen. 'im1' und 'im2' stellen Images dar, die den Knopf in     *)
  1048. (* unaktiviertem und aktiviertem Zustand darstellen. Wenn hier          *)
  1049. (* 'noImage' (NIL) angegeben wird, wird der Standartknopf von Intuition *)
  1050. (* benutzt (ein ausgefülltes Rechteck). Die letzten Werte geben die     *)
  1051. (* Auflösung des Reglers an. 'xr' und 'yr' geben die maximalen Elemente *)
  1052. (* des Reglers an. Wenn bei einem der beiden 0 angegeben wird, ist      *)
  1053. (* eine Verschiebung des Reglers in die jeweilige Richtung nicht        *)
  1054. (* möglich. 'xd' und 'yd' sind die Elemente die dargestellt werden      *)
  1055. (* können und 'xp' und 'yp' die Position des Knopfes bei Öffnung des    *)
  1056. (* Reglers. Die Positionen können im Bereich von 0..x/yr-1 liegen.      *)
  1057. (* Um die Belegung der Werte etwas zu veranschaulichen, folgt hier ein  *)
  1058. (* Beispiel. Man möchte für einen File-Requester ein Schieberegler      *)
  1059. (* einsetzen mit dem man zwischen den Positionen herrollen kann.        *)
  1060. (* Auf dem Bildschirm finden 11 Filenamen untereinander Platz. Im       *)
  1061. (* Moment befinden sich im Speicher 108 Filenamen die dargestellt       *)
  1062. (* werden können. Die Auflösung in Y-Richtung beträgt also 'yr':=       *)
  1063. (* 108-11; die Darstellung beträgt 'yd':=11; und die Position 'yp' kann *)
  1064. (* im Bereich von 0..(108-11-1) liegen. Für einen Farbregler für die    *)
  1065. (* Werte von 0..15 müßte also z.B. 'xr':=16; 'xd':=1; und 'xp':=0..15   *)
  1066. (* sein, für einen horizontalen Regler.                                 *)
  1067.  
  1068. PROCEDURE AddPropGadget(gh       : GadgetHandlePtr;
  1069.                         x,y      : INTEGER;
  1070.                         w,h      : INTEGER;
  1071.                         id       : INTEGER;
  1072.                         im1,im2  : ImagePtr;
  1073.                         flags    : PropGadgetFlagSet;
  1074.                         xr,yr    : CARDINAL;
  1075.                         xd,yd    : CARDINAL;
  1076.                         xp,yp    : CARDINAL) : GadgetsPtr;
  1077.  
  1078.  
  1079.  
  1080. (* 'AddStringGadget' fügt ein Stringgadget in das Window/Requester      *)
  1081. (* ein. Die Parameter 'x' bis 'id' entsprechen wieder den Parametern    *)
  1082. (* in den Funktionen 'Add...BoolGadget'. 'b' enthält, wenn gewünscht,   *)
  1083. (* einen Border für das jeweilige Stringgadget. 'max' gibt die maximale *)
  1084. (* Anzahl Zeichen im Puffer fest. 'dp' steht für DisplayPosition und    *)
  1085. (* legt das Zeichen fest, daß als erstes im Puffer zu sehen ist. Dieses *)
  1086. (* kann bei Strings benutzt werden, bei denen die Texte länger als das  *)
  1087. (* Gadget ist. 'bp' ist die BufferPosition und legt fest auf welcher    *)
  1088. (* Position sich der Cursor befindet. In 'keyMap' kann eine alternative *)
  1089. (* Tastaturbelegung übergeben werden. Wenn die Standartkeymap benutzt   *)
  1090. (* werden soll, muß hier NIL angegeben werden. 'text' wird im Buffer    *)
  1091. (* bei der Aktivierung angezeigt. Wenn kein Text gewünscht ist, kann    *)
  1092. (* in 'text' 'none' übergeben werden. In 'li' kann man für Longint-     *)
  1093. (* Stringgadgets einen Vorgabewert setzen.                              *)
  1094.  
  1095. PROCEDURE AddStringGadget(gh     : GadgetHandlePtr;
  1096.                           x,y    : INTEGER;
  1097.                           w,h    : INTEGER;
  1098.                           id     : INTEGER;
  1099.                           b      : BorderPtr;
  1100.                           max    : INTEGER;
  1101.                           dp,bp  : INTEGER;
  1102.                           flags  : StringGadgetFlagSet;
  1103.                           keyMap : KeyMapPtr;
  1104.                           text   : ARRAY OF CHAR;
  1105.                           li     : LONGINT) : GadgetsPtr;
  1106.  
  1107.  
  1108.  
  1109. (* 'DisplayGadget' zeigt ein Gadget, das mittels einer der Funktionen   *)
  1110. (* 'Add...Gadget' erzeugt wurde, in dem in 'InitGadgetList' angegebenen *)
  1111. (* Fenster/Requester an.                                                *)
  1112.  
  1113. PROCEDURE DisplayGadget(g : GadgetsPtr);
  1114.  
  1115.  
  1116.  
  1117. (* 'DisplayAllGadgets' arbeitet wie 'DisplayGadget', nur werden alle    *)
  1118. (* Gadgets in der Liste angezeigt.                                      *)
  1119.  
  1120. PROCEDURE DisplayAllGadgets(gh : GadgetHandlePtr);
  1121.  
  1122.  
  1123.  
  1124. (* 'GadgetEnable' erlaubt es Gadgets anwählbar bzw. nicht anwählbar     *)
  1125. (* zu schalten. Wenn 'enable' 'enabled' (TRUE) ist, kann man das Gadget *)
  1126. (* anwählen, bei 'diabled' (FALSE) kann man es nicht.                   *)
  1127.  
  1128. PROCEDURE GadgetEnable(g      : GadgetsPtr;
  1129.                        enable : BOOLEAN);
  1130.  
  1131.  
  1132.  
  1133. (* 'ActivateStringGadget' ermöglicht es dem Programmierer ein           *)
  1134. (* bestimmtes Stringgadgets so zu aktivieren, daß der Benutzer, ohne    *)
  1135. (* daß er erst das Gadget mit der Maus anwählen muß, gleich drauflos-   *)
  1136. (* schreiben kann.                                                      *)
  1137.  
  1138. PROCEDURE ActivateStringGadget(gh  : GadgetHandlePtr;
  1139.                                g   : GadgetsPtr);
  1140.  
  1141.  
  1142.  
  1143. (* 'GetGadgetSelection' ermittelt die Anwahl bzw. das Loslassen des     *)
  1144. (* Gadgets. Wenn ein Gadget gedrückt wurde, wird TRUE zurückgegeben,    *)
  1145. (* ansonsten FALSE.                                                     *)
  1146.  
  1147. PROCEDURE GetGadgetSelection(win    : WindowPtr;
  1148.                              VAR id : INTEGER) : BOOLEAN;
  1149.  
  1150.  
  1151.  
  1152. (* 'GetPropPosition' besorgt sich von einem Proportionalgadget die      *)
  1153. (* aktuelle Schieberposition. Diese können wie bei 'AddPropGadget' in   *)
  1154. (* dem Bereich 0..x/yr-1 liegen, welche bei der Erzeugung angegeben     *)
  1155. (* wurden.                                                              *)
  1156.  
  1157. PROCEDURE GetPropPosition(g         : GadgetsPtr;
  1158.                           VAR xp,yp : CARDINAL);
  1159.  
  1160.  
  1161.  
  1162. (* 'SetPropGadget' ermöglicht es nachträglich ein Proportionalgadget    *)
  1163. (* zu verändern. Es können alle Schieberwerte genauso wie bei           *)
  1164. (* 'AddPropGadget' angegeben werden. Das Gadget wird optisch sofort     *)
  1165. (* erneuert.                                                            *)
  1166.  
  1167. PROCEDURE SetPropGadget(g     : GadgetsPtr;
  1168.                         xr,yr : CARDINAL;
  1169.                         xd,yd : CARDINAL;
  1170.                         xp,yp : CARDINAL);
  1171.  
  1172.  
  1173.  
  1174. (* 'GetStringContents' liest den Buffer eines Stringgadgets aus. Wenn   *)
  1175. (* es sich um ein Longint-Stringgadget handelt, enthält 'li' den        *)
  1176. (* aktuellen LONGINT-Wert seit der letzten Bestätigung mit <RETURN>.    *)
  1177.  
  1178. PROCEDURE GetStringContents(g       : GadgetsPtr;
  1179.                             VAR str : ARRAY OF CHAR;
  1180.                             VAR li  : LONGINT);
  1181.  
  1182.  
  1183.  
  1184. (* 'FreeGadget' entfernt ein Gadget von dem Window/Requester und gibt   *)
  1185. (* alle belegten Strukturen wieder frei.                                *)
  1186.  
  1187. PROCEDURE FreeGadget(gh     : GadgetHandlePtr;
  1188.                      VAR g  : GadgetsPtr);
  1189.  
  1190.  
  1191.  
  1192. (* 'FreeGadgetList' gibt alle Gadgets einer Liste frei und dann die     *)
  1193. (* Liste. Alle Gadgets werden entfernt und der ganze belegte Speicher   *)
  1194. (* wird wieder freigegeben.                                             *)
  1195.  
  1196. PROCEDURE FreeGadgetList(VAR gh : GadgetHandlePtr);
  1197.  
  1198.  
  1199.  
  1200. (* 'GetRequester' legt ein Requester in ein Window. 'x','y','w' und     *)
  1201. (* 'h' geben die Position und Größen des Requesters im Window dar.      *)
  1202. (* 'border' enthält einen Border zur Umrandung des Requesters. 'text'   *)
  1203. (* ist ein Zeiger auf eine (verkettete) IntuiTextStruktur. 'bitMap'     *)
  1204. (* kann angegeben werden, wenn der Requester eine vorbereitete BitMap   *)
  1205. (* benutzen soll, ansonsten muß NIL angegeben werden. 'fill' gibt eine  *)
  1206. (* Hintergrundfarbe des Requesters an. Bei relativen DM-Requester muß   *)
  1207. (* beachtet werden, daß der Requester nur in dem jeweiligen Window      *)
  1208. (* erscheint, je nach Mausposition. Das Window bewegt sich NICHT!       *)
  1209. (* In 'gh' kann man schon sofort bei Erstellung des Requesters eine     *)
  1210. (* Gadgetliste übergeben, die in den Requester eingebunden werden soll. *)
  1211. (* Dazu muß in 'InitGadgetList' die Parameter 'window' und 'requester'  *)
  1212. (* auf NIL gesetzt werden! Andere Listen werden nicht angenommen!       *)
  1213. (* Dieses hat einige Vorteile gegenüber dem nachträglichen Einbinden    *)
  1214. (* und sollte wenn immer möglich benutzt werden!                        *)
  1215.  
  1216. PROCEDURE GetRequester(window : WindowPtr;
  1217.                        x,y    : INTEGER;
  1218.                        w,h    : INTEGER;
  1219.                        border : BorderPtr;
  1220.                        text   : IntuiTextPtr;
  1221.                        gh     : GadgetHandlePtr;
  1222.                        bitMap : BitMapPtr;
  1223.                        flags  : RequestFlagSet;
  1224.                        fill   : SHORTCARD) : RequesterPtr;
  1225.  
  1226.  
  1227.  
  1228. (* 'GetReqRastPort' besorgt den Zeiger auf den  RastPort des Requesters.*)
  1229. (* So kann man direkt (ohne Intuition) den Requester mit den Zeichen-   *)
  1230. (* befehlen aus Graphics bzw. GraphicsSupport beschreiben.              *)
  1231. (* Allerdings muß man sich DoubleMenu-Requestern vorsehen : Wenn der    *)
  1232. (* Requester sich momentan nicht bzw. noch nicht auf dem Bildschirm     *)
  1233. (* befindet, existiert kein Rastport und es wird NIL zurückgegeben.     *)
  1234. (* Es muß vor Zeichenoperationen also geprüft werden, ob der zurück-    *)
  1235. (* gegebene Zeiger nicht Null (NIL) ist!!!                              *)
  1236.  
  1237. PROCEDURE GetReqRastPort(req : RequesterPtr) : RastPortPtr;
  1238.  
  1239.  
  1240.  
  1241. (* 'EndDMRequester' beendet einen DM-Requester und löscht ihn vom       *)
  1242. (* Bildschirm. Er ist dann für einen weiteren Aufruf durch einen        *)
  1243. (* Doppelklick auf die Menuauswahltaste bereit. Erst ein Aufruf von     *)
  1244. (* 'FreeRequester' entfernt ihn endgültig.                              *)
  1245.  
  1246. PROCEDURE EndDMRequester(req : RequesterPtr);
  1247.  
  1248.  
  1249.  
  1250. (* 'FreeRequester' entfernt ein mittels 'GetRequester' erzeugter        *)
  1251. (* Requester vom Window und gibt alle Structuren frei.                  *)
  1252.  
  1253. PROCEDURE FreeRequester(VAR req : RequesterPtr);
  1254.  
  1255.  
  1256.  
  1257. (* 'GetIntuiMessage' liest eine allgemeine Intuitionnachricht aus.      *)
  1258. (* Wenn eine Nachricht ausgelesen werden konnte, wird TRUE zurück-      *)
  1259. (* gegeben, ansonsten FALSE.                                            *)
  1260.  
  1261. PROCEDURE GetIntuiMessage(window  : WindowPtr;
  1262.                           VAR msg : IntuiMessage) : BOOLEAN;
  1263.  
  1264.  
  1265.  
  1266. (* 'GetActiveWindow' besorgt den Zeiger auf die Windowstruktur des      *)
  1267. (* momentan aktiven Windows. Dieser Befehl sollte nicht dazu benutzt    *)
  1268. (* werden, um Änderungen oder ähnliches an fremden Fenstern auszuführen!*)
  1269. (* Die Benutzung dieses Befehls zur Manipulation verstößt gegen die     *)
  1270. (* Programmierrichtlinien von Commodore. (z.B. Verstoß in der MMU)      *)
  1271. (* Es kann nähmlich passieren, daß das aktive Fenster noch während      *)
  1272. (* der Zeiger abgearbeitet wird, von einem anderen Task geschlossen     *)
  1273. (* wird und der Zeiger auf einen freien Speicherbereich zeigt!          *)
  1274.  
  1275. PROCEDURE GetActiveWindow() : WindowPtr;
  1276.  
  1277.  
  1278.  
  1279. (* Für 'GetActiveScreen' gilt das gleiche das unter 'GetActiveWindow'   *)
  1280. (* gesagt wurde.                                                        *)
  1281.  
  1282. PROCEDURE GetActiveScreen() : ScreenPtr;
  1283.  
  1284. END IntuitionSupport.
  1285.